package com.freeter.modules.gjs.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.freeter.modules.gjs.entity.MstrItems;
import com.freeter.modules.gjs.entity.MstrCat00;
import com.freeter.modules.gjs.entity.MstrCat01;
import com.freeter.modules.gjs.entity.MstrCat02;
import com.freeter.modules.gjs.mapper.MstrItemsMapper;
import com.freeter.modules.gjs.mapper.MstrCat00Mapper;
import com.freeter.modules.gjs.mapper.MstrCat01Mapper;
import com.freeter.modules.gjs.mapper.MstrCat02Mapper;
import com.freeter.modules.gjs.service.MstrItemsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;

@Service
public class MstrItemsServiceImpl implements MstrItemsService {
    @Autowired
    private MstrItemsMapper mstrItemsMapper;
    
    @Autowired
    private MstrCat00Mapper mstrCat00Mapper;
    
    @Autowired
    private MstrCat01Mapper mstrCat01Mapper;
    
    @Autowired
    private MstrCat02Mapper mstrCat02Mapper;

    public List<MstrItems> getItemsByCondition(String name, Integer state) {
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        if (name != null) wrapper.eq("item_desc", name);
        if (state != null) wrapper.eq("is_deleted", state);
        return mstrItemsMapper.selectList(wrapper);
    }

    @Override
    public List<MstrItems> getAllItems() {
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        wrapper.eq("is_deleted", 0); // 只查询未删除的商品
        return mstrItemsMapper.selectList(wrapper);
    }

    @Override
    public MstrItems getItemById(Long id) {
        if (id == null) {
            return null;
        }
        return mstrItemsMapper.selectById(id);
    }

    @Override
    public MstrItems getItemByCode(String itemCode) {
        if (StringUtils.isEmpty(itemCode)) {
            return null;
        }
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        wrapper.eq("item_barcode", itemCode);
        wrapper.eq("is_deleted", 0);
        List<MstrItems> items = mstrItemsMapper.selectList(wrapper);
        return items.isEmpty() ? null : items.get(0);
    }

    @Override
    public List<MstrItems> getItemsByCat00Code(String cat00Code) {
        if (StringUtils.isEmpty(cat00Code)) {
            return null;
        }
        
        // 先查询cat00Code对应的分类ID
        MstrCat00 cat00 = mstrCat00Mapper.selectById(cat00Code);
        if (cat00 == null) {
            return new ArrayList<>(); // 分类不存在，返回空列表
        }
        
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        // 使用查询到的分类ID构建LIKE查询条件
        wrapper.like("cat_id", cat00.getId().toString() + "%");
        wrapper.eq("is_deleted", 0);
        return mstrItemsMapper.selectList(wrapper);
    }

    @Override
    public List<MstrItems> getItemsByCat01Code(String cat01Code) {
        if (StringUtils.isEmpty(cat01Code)) {
            return null;
        }
        
        // 先查询cat01Code对应的分类ID
        MstrCat01 cat01 = mstrCat01Mapper.selectById(cat01Code);
        if (cat01 == null) {
            return new ArrayList<>(); // 分类不存在，返回空列表
        }
        
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        // 使用查询到的分类ID构建LIKE查询条件
        wrapper.like("cat_id", cat01.getPlevel().toString() + cat01.getId().toString() + "%");
        wrapper.eq("is_deleted", 0);
        return mstrItemsMapper.selectList(wrapper);
    }

    @Override
    public List<MstrItems> getItemsByCat02Code(String cat02Code) {
        if (StringUtils.isEmpty(cat02Code)) {
            return null;
        }
        
        // 先查询cat02Code对应的分类ID
        String catId = "";
        MstrCat02 cat02 = mstrCat02Mapper.selectById(cat02Code);
        if (cat02 == null) {
            return new ArrayList<>(); // 分类不存在，返回空列表
        }
        if(!StringUtils.isEmpty(cat02.getPlevel())){
            MstrCat01 cat01 = mstrCat01Mapper.selectById(cat02.getPlevel());
            catId = cat01.getPlevel().toString() + cat01.getId().toString() + cat02.getId().toString();
        }else{
            catId = "%" + cat02.getId().toString() + "%";
        }
              
        
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        // 使用查询到的分类ID构建LIKE查询条件
        wrapper.like("cat_id", catId);
        wrapper.eq("is_deleted", 0);
        return mstrItemsMapper.selectList(wrapper);
    }

    @Override
    public List<MstrItems> getItemsByDivisionCode(String divisionCode) {
        if (StringUtils.isEmpty(divisionCode)) {
            return null;
        }
        // 注意：MstrItems 实体中没有 divisionCode 字段，这里可能需要根据实际业务需求调整
        // 暂时返回空列表，或者可以扩展实体类添加该字段
        return null;
    }

    @Override
    public List<MstrItems> getItemsByUomCode(String uomCode) {
        if (StringUtils.isEmpty(uomCode)) {
            return null;
        }
        // 注意：MstrItems 实体中 uomId 是 Long 类型，这里需要根据实际业务需求调整
        // 如果 uomCode 是字符串，可能需要先查询 UOM 表获取 ID
        return null;
    }

    @Override
    public MstrItems createItem(MstrItems item) {
        if (item == null) {
            return null;
        }
        
        // 设置创建时间和删除标记
        item.setCreatedt(new Date());
        item.setIsDeleted(0);
        
        // 如果 ID 为空，设置为 null 让数据库自动生成
        if (item.getId() != null) {
            item.setId(null);
        }
        
        int result = mstrItemsMapper.insert(item);
        return result > 0 ? item : null;
    }

    @Override
    public MstrItems updateItem(Long id, MstrItems item) {
        if (id == null || item == null) {
            return null;
        }
        
        // 检查商品是否存在
        MstrItems existingItem = mstrItemsMapper.selectById(id);
        if (existingItem == null) {
            return null;
        }
        
        // 设置 ID 和更新时间
        item.setId(id);
        item.setCreatedt(existingItem.getCreatedt()); // 保持原始创建时间
        
        int result = mstrItemsMapper.updateById(item);
        return result > 0 ? item : null;
    }

    @Override
    public void deleteItem(Long id) {
        if (id == null) {
            return;
        }
        
        // 软删除：设置删除标记
        MstrItems item = new MstrItems();
        item.setId(id);
        item.setIsDeleted(1);
        mstrItemsMapper.updateById(item);
    }

    @Override
    public void deleteItemByCode(String itemCode) {
        if (StringUtils.isEmpty(itemCode)) {
            return;
        }
        
        // 先查询商品，然后软删除
        MstrItems item = getItemByCode(itemCode);
        if (item != null) {
            deleteItem(item.getId());
        }
    }

    @Override
    public List<MstrItems> getItemsByStatus(String status) {
        if (StringUtils.isEmpty(status)) {
            return null;
        }
        Wrapper<MstrItems> wrapper = new EntityWrapper<>();
        wrapper.eq("is_deleted", Integer.valueOf(status));
        return mstrItemsMapper.selectList(wrapper);
    }
} 